home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / dns / rdata.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  9KB  |  302 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import dns.exception as dns
  5. import dns.rdataclass as dns
  6. import dns.rdatatype as dns
  7. import dns.tokenizer as dns
  8. _hex_chunksize = 32
  9.  
  10. def _hexify(data, chunksize = None):
  11.     if chunksize is None:
  12.         chunksize = _hex_chunksize
  13.     
  14.     hex = data.encode('hex_codec')
  15.     l = len(hex)
  16.     if l > chunksize:
  17.         chunks = []
  18.         i = 0
  19.         while i < l:
  20.             chunks.append(hex[i:i + chunksize])
  21.             i += chunksize
  22.         hex = ' '.join(chunks)
  23.     
  24.     return hex
  25.  
  26. _base64_chunksize = 32
  27.  
  28. def _base64ify(data, chunksize = None):
  29.     if chunksize is None:
  30.         chunksize = _base64_chunksize
  31.     
  32.     b64 = data.encode('base64_codec')
  33.     b64 = b64.replace('\n', '')
  34.     l = len(b64)
  35.     if l > chunksize:
  36.         chunks = []
  37.         i = 0
  38.         while i < l:
  39.             chunks.append(b64[i:i + chunksize])
  40.             i += chunksize
  41.         b64 = ' '.join(chunks)
  42.     
  43.     return b64
  44.  
  45. __escaped = {
  46.     '"': True,
  47.     '\\': True }
  48.  
  49. def _escapify(qstring):
  50.     text = ''
  51.     for c in qstring:
  52.         if c in __escaped:
  53.             text += '\\' + c
  54.             continue
  55.         if ord(c) >= 32 and ord(c) < 127:
  56.             text += c
  57.             continue
  58.         text += '\\%03d' % ord(c)
  59.     
  60.     return text
  61.  
  62.  
  63. def _truncate_bitmap(what):
  64.     for i in xrange(len(what) - 1, -1, -1):
  65.         if what[i] != '\x00':
  66.             break
  67.             continue
  68.     
  69.     return ''.join(what[0:i + 1])
  70.  
  71.  
  72. class Rdata(object):
  73.     __slots__ = [
  74.         'rdclass',
  75.         'rdtype']
  76.     
  77.     def __init__(self, rdclass, rdtype):
  78.         self.rdclass = rdclass
  79.         self.rdtype = rdtype
  80.  
  81.     
  82.     def covers(self):
  83.         return dns.rdatatype.NONE
  84.  
  85.     
  86.     def extended_rdatatype(self):
  87.         return self.covers() << 16 | self.rdtype
  88.  
  89.     
  90.     def to_text(self, origin = None, relativize = True, **kw):
  91.         raise NotImplementedError
  92.  
  93.     
  94.     def to_wire(self, file, compress = None, origin = None):
  95.         raise NotImplementedError
  96.  
  97.     
  98.     def validate(self):
  99.         dns.rdata.from_text(self.rdclass, self.rdtype, self.to_text())
  100.  
  101.     
  102.     def __repr__(self):
  103.         covers = self.covers()
  104.         if covers == dns.rdatatype.NONE:
  105.             ctext = ''
  106.         else:
  107.             ctext = '(' + dns.rdatatype.to_text(covers) + ')'
  108.         return '<DNS ' + dns.rdataclass.to_text(self.rdclass) + ' ' + dns.rdatatype.to_text(self.rdtype) + ctext + ' rdata: ' + str(self) + '>'
  109.  
  110.     
  111.     def __str__(self):
  112.         return self.to_text()
  113.  
  114.     
  115.     def _cmp(self, other):
  116.         raise NotImplementedError
  117.  
  118.     
  119.     def __eq__(self, other):
  120.         if not isinstance(other, Rdata):
  121.             return False
  122.         
  123.         if self.rdclass != other.rdclass or self.rdtype != other.rdtype:
  124.             return False
  125.         
  126.         return self._cmp(other) == 0
  127.  
  128.     
  129.     def __ne__(self, other):
  130.         if not isinstance(other, Rdata):
  131.             return True
  132.         
  133.         if self.rdclass != other.rdclass or self.rdtype != other.rdtype:
  134.             return True
  135.         
  136.         return self._cmp(other) != 0
  137.  
  138.     
  139.     def __lt__(self, other):
  140.         if not isinstance(other, Rdata) and self.rdclass != other.rdclass or self.rdtype != other.rdtype:
  141.             return NotImplemented
  142.         
  143.         return self._cmp(other) < 0
  144.  
  145.     
  146.     def __le__(self, other):
  147.         if not isinstance(other, Rdata) and self.rdclass != other.rdclass or self.rdtype != other.rdtype:
  148.             return NotImplemented
  149.         
  150.         return self._cmp(other) <= 0
  151.  
  152.     
  153.     def __ge__(self, other):
  154.         if not isinstance(other, Rdata) and self.rdclass != other.rdclass or self.rdtype != other.rdtype:
  155.             return NotImplemented
  156.         
  157.         return self._cmp(other) >= 0
  158.  
  159.     
  160.     def __gt__(self, other):
  161.         if not isinstance(other, Rdata) and self.rdclass != other.rdclass or self.rdtype != other.rdtype:
  162.             return NotImplemented
  163.         
  164.         return self._cmp(other) > 0
  165.  
  166.     
  167.     def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True):
  168.         raise NotImplementedError
  169.  
  170.     from_text = classmethod(from_text)
  171.     
  172.     def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None):
  173.         raise NotImplementedError
  174.  
  175.     from_wire = classmethod(from_wire)
  176.     
  177.     def choose_relativity(self, origin = None, relativize = True):
  178.         pass
  179.  
  180.  
  181.  
  182. class GenericRdata(Rdata):
  183.     __slots__ = [
  184.         'data']
  185.     
  186.     def __init__(self, rdclass, rdtype, data):
  187.         super(GenericRdata, self).__init__(rdclass, rdtype)
  188.         self.data = data
  189.  
  190.     
  191.     def to_text(self, origin = None, relativize = True, **kw):
  192.         return '\\# %d ' % len(self.data) + _hexify(self.data)
  193.  
  194.     
  195.     def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True):
  196.         if tok.get_string() != '\\#':
  197.             raise dns.exception.SyntaxError, 'generic rdata does not start with \\#'
  198.         
  199.         length = tok.get_int()
  200.         chunks = []
  201.         while None:
  202.             (ttype, value) = tok.get()
  203.             if ttype == dns.tokenizer.EOL or ttype == dns.tokenizer.EOF:
  204.                 break
  205.             
  206.             continue
  207.             hex = ''.join(chunks)
  208.             data = hex.decode('hex_codec')
  209.             if len(data) != length:
  210.                 raise dns.exception.SyntaxError, 'generic rdata hex data has wrong length'
  211.             
  212.         return cls(rdclass, rdtype, data)
  213.  
  214.     from_text = classmethod(from_text)
  215.     
  216.     def to_wire(self, file, compress = None, origin = None):
  217.         file.write(self.data)
  218.  
  219.     
  220.     def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None):
  221.         return cls(rdclass, rdtype, wire[current:current + rdlen])
  222.  
  223.     from_wire = classmethod(from_wire)
  224.     
  225.     def _cmp(self, other):
  226.         return cmp(self.data, other.data)
  227.  
  228.  
  229. _rdata_modules = { }
  230. _module_prefix = 'dns.rdtypes'
  231.  
  232. def get_rdata_class(rdclass, rdtype):
  233.     
  234.     def import_module(name):
  235.         mod = __import__(name)
  236.         components = name.split('.')
  237.         for comp in components[1:]:
  238.             mod = getattr(mod, comp)
  239.         
  240.         return mod
  241.  
  242.     mod = _rdata_modules.get((rdclass, rdtype))
  243.     rdclass_text = dns.rdataclass.to_text(rdclass)
  244.     rdtype_text = dns.rdatatype.to_text(rdtype)
  245.     rdtype_text = rdtype_text.replace('-', '_')
  246.     if not mod:
  247.         mod = _rdata_modules.get((dns.rdatatype.ANY, rdtype))
  248.         if not mod:
  249.             
  250.             try:
  251.                 mod = import_module('.'.join([
  252.                     _module_prefix,
  253.                     rdclass_text,
  254.                     rdtype_text]))
  255.                 _rdata_modules[(rdclass, rdtype)] = mod
  256.             except ImportError:
  257.                 
  258.                 try:
  259.                     mod = import_module('.'.join([
  260.                         _module_prefix,
  261.                         'ANY',
  262.                         rdtype_text]))
  263.                     _rdata_modules[(dns.rdataclass.ANY, rdtype)] = mod
  264.                 except ImportError:
  265.                     mod = None
  266.                 except:
  267.                     None<EXCEPTION MATCH>ImportError
  268.                 
  269.  
  270.                 None<EXCEPTION MATCH>ImportError
  271.             
  272.  
  273.         None<EXCEPTION MATCH>ImportError
  274.     
  275.     if mod:
  276.         cls = getattr(mod, rdtype_text)
  277.     else:
  278.         cls = GenericRdata
  279.     return cls
  280.  
  281.  
  282. def from_text(rdclass, rdtype, tok, origin = None, relativize = True):
  283.     if isinstance(tok, str):
  284.         tok = dns.tokenizer.Tokenizer(tok)
  285.     
  286.     cls = get_rdata_class(rdclass, rdtype)
  287.     if cls != GenericRdata:
  288.         token = tok.get()
  289.         tok.unget(token)
  290.         if token[0] == dns.tokenizer.IDENTIFIER and token[1] == '\\#':
  291.             rdata = GenericRdata.from_text(rdclass, rdtype, tok, origin, relativize)
  292.             return from_wire(rdclass, rdtype, rdata.data, 0, len(rdata.data), origin)
  293.         
  294.     
  295.     return cls.from_text(rdclass, rdtype, tok, origin, relativize)
  296.  
  297.  
  298. def from_wire(rdclass, rdtype, wire, current, rdlen, origin = None):
  299.     cls = get_rdata_class(rdclass, rdtype)
  300.     return cls.from_wire(rdclass, rdtype, wire, current, rdlen, origin)
  301.  
  302.